home *** CD-ROM | disk | FTP | other *** search
/ PsL Monthly 1993 December / PSL Monthly Shareware CD-ROM (December 1993).iso / prgmming / dos / c / stdlib1.exe / lha / SPRINTF.ASM < prev    next >
Assembly Source File  |  1990-07-09  |  16KB  |  819 lines
  1. stdlib        segment    para public 'slcode'
  2.         assume    cs:stdlib
  3.         extrn    sl_ISize:far, sl_ULSize:far
  4.         extrn    sl_LSize:far, sl_USize:far
  5.         extrn    sl_itoa:far, sl_free:far
  6.         extrn    sl_wtoa:far, sl_ltoa:far
  7.         extrn    sl_ultoa:far, sl_htoa:far
  8.         extrn    sl_utoa:far
  9.         extrn    sl_malloc:far, sl_realloc:far
  10. ;
  11. ;
  12. ;
  13. ; Sprintf- Like the "C" routine by the same name.  Calling sequence:
  14. ;
  15. ;               call    sprintf
  16. ;               db      "format string",0
  17. ;               dd      item1, item2, ..., itemn
  18. ;
  19. ; Just like the PRINTF routine except it performs an in-memory format
  20. ; operation rather than printing the data to the current output device.
  21. ; Returns a pointer to the formatted string in ES:DI.
  22. ; See the PRINTF routine for more details about this guy.
  23. ;
  24. ;
  25. cr        equ    0dh
  26. ff        equ    0ch
  27. lf        equ    0ah
  28. tab        equ    09h
  29. bs        equ    08h
  30. ;
  31. RtnAdrs        equ    2[bp]
  32. ;
  33. ;
  34. ; 
  35. aindex        dw    ?
  36. aptr        dd    ?
  37. ;
  38. ;
  39. ; sp_BufSize is a public variable so the user can adjust the size.
  40. ;
  41.         public    sp_BufSize
  42. sp_BufSize    dw    2048
  43. ;
  44. ;
  45.         public    sl_sprintf
  46. sl_sprintf    proc    far
  47.         push    bp
  48.         mov    bp, sp
  49.         pushf
  50.         push    ax cx
  51. ;
  52. ; Request some memory from the system.  If there isn't enough available,
  53. ; try half as much and repeat.  If there is no memory available, return
  54. ; with the carry set.
  55. ;
  56.         mov    cx, sp_BufSize
  57. TryAgain:    call    sl_malloc
  58.         jnc    DoSPRINTF
  59.         shr    cx, 1
  60.         cmp    cx, 128            ;Need at least 128 bytes.
  61.         jae    TryAgain
  62.         pop    cx ax
  63.         popf
  64.                 pop    bp
  65.         stc
  66.         ret
  67. ;
  68. ; The following code simulates a far call to sbprintf.  We can't make the
  69. ; call because we need to skip the MOV BP, SP instruction which appears
  70. ; at the beginning of the code.
  71. ;
  72. DoSPRINTF:         push    cs            ;Push fake return address
  73.         mov    ax, offset RA
  74.         push    ax
  75.         push    bp            ;Push stuff on stack
  76.         pushf
  77.         push    ax bx cx dx di si es ds
  78.         jmp    sl_sbprintf2
  79. ;
  80. ; Return back to this point from sbprintf.
  81. ;
  82. RA:        push    di
  83.         mov    cx, 1
  84.         mov    al, ch
  85. FindLength:    cmp    al, es:[di]
  86.         jz    AtEnd
  87.         inc    cx
  88.         inc    di
  89.         jmp    FindLength
  90. ;
  91. AtEnd:        pop    di
  92.         call    sl_realloc
  93.         pop    cx ax
  94.         popf
  95.                 pop    bp
  96.         clc
  97.         ret        
  98. sl_sprintf    endp
  99. ;
  100. ;
  101. ;
  102. ;
  103. ; SBPRINTF- Like sprintf except it doesn't allocate storage for the
  104. ; formatted string.  Instead, you must pass it the address of a suitable
  105. ; buffer in es:di.
  106. ;
  107. ;
  108.         public  sl_sbprintf
  109. sl_sbprintf    proc    far
  110.         push    bp
  111.         mov    bp, sp
  112.         pushf
  113.         push    ax bx cx dx di si es ds
  114. ;
  115. ; Save ptr to buffer area.
  116. ;
  117. sl_sbprintf2:    mov    word ptr cs:aptr, di
  118.         mov    word ptr cs:aptr+2, es
  119.         mov    cs:aindex, 0
  120. ;
  121. ; Get pointers to the return address (format string).
  122. ;
  123.         cld
  124.         les    di, RtnAdrs
  125.         lds    si, RtnAdrs
  126. ;
  127. ; Okay, search for the end of the format string.  After these instructions,
  128. ; di points just beyond the zero byte at the end of the format string.  This,
  129. ; of course, points at the first address beyond the format string.
  130. ;
  131.         mov    al, 0
  132.         mov    cx, 65535
  133.     repne    scasb
  134. ;
  135. PrintItems:    lodsb            ;Get char si points at.
  136.         cmp    al, 0        ;EOS?
  137.         jz    PrintfDone
  138.         cmp    al, "%"        ;Start of a format string?
  139.         jz    FmtItem
  140.         cmp    al, "\"        ;Escape character?
  141.         jnz    PrintIt
  142.         call    GetEscChar
  143. PrintIt:    call    PutIt
  144.         jmp    PrintItems
  145. ;
  146. FmtItem:    call    GetFmtItem    ;Process the format item here.
  147.         jmp    PrintItems
  148. ;
  149. PrintfDone:    mov    RtnAdrs, di    ;Put out new return address.
  150.         pop    ds
  151.         pop    es
  152.         pop    si
  153.         pop    di
  154.         pop    dx
  155.         pop    cx
  156.         pop    bx
  157.         pop    ax
  158.         pop    bp
  159.         popf
  160.         clc
  161.         ret
  162. sl_sbprintf    endp
  163. ;
  164. ; GetEscChar- Handles items immediately following the escape character "\".
  165. ;
  166. ;    Special escape characters (upper/lower case is acceptable):
  167. ;
  168. ;        n    Newline (cr/lf)
  169. ;        t    tab
  170. ;        b    backspace
  171. ;        r    return
  172. ;        l    line feed
  173. ;        f    formfeed
  174. ;        \    \
  175. ;        %    &
  176. ;        0xhh    Char with hex character code hh.  Must have exactly
  177. ;            two hexadecimal digits.
  178. ;
  179. GetEscChar    proc    near
  180.         lodsb            ;Get next character
  181.         cmp    al, 'n'
  182.         je    RtnNL
  183.         cmp    al, 'N'
  184.         je    RtnNL
  185.         cmp    al, 't'
  186.         je    RtnTab
  187.         cmp    al, 'T'
  188.         je    RtnTab
  189.         cmp    al, 'b'
  190.         je    RtnBS
  191.         cmp    al, 'B'
  192.         je    RtnBS
  193.         cmp    al, 'r'
  194.         je    RtnRtn
  195.         cmp    al, 'R'
  196.         je    RtnRtn
  197.         cmp    al, 'l'
  198.         je    RtnLF
  199.         cmp    al, 'L'
  200.         je    RtnLF
  201.         cmp    al, 'f'
  202.         je    RtnFF
  203.         cmp    al, 'F'
  204.         je    RtnFF
  205. ;
  206. ; Check for the presence of a 0xhh value here:
  207. ;
  208.         cmp    al, '0'
  209.         jne    RtnChar
  210.         cmp    byte ptr [si], 'x'
  211.         je    GetHex
  212.         cmp    byte ptr [si], 'X'
  213.         jne    RtnChar
  214. ;
  215. ; Okay, process the hex value here.  Note that exactly two hex digits must
  216. ; follow the 0x.
  217. ;
  218. GetHex:        inc    si        ;Point at first hex digit.
  219.         lodsb            ;Get first hex digit.
  220.         and    al, 05fh    ;l.c. -> u.c.
  221.         cmp    al, 'A'
  222.         jb    GotIt
  223.         sub    al, '7'
  224. GotIt:        shl    al, 1        ;Put into H.O. nibble.
  225.         shl    al, 1
  226.         shl    al, 1
  227.         shl    al, 1
  228.         mov    ah, al        ;Save for later
  229.         lodsb            ;Get next char.
  230.         and    al, 05fh
  231.         cmp    al, 'A'
  232.         jb    GotIt2
  233.         sub    al, '7'
  234. GotIt2:        and    al, 0fh
  235.         or    al, ah
  236.         ret            ;Return hex constant.
  237. ;
  238. ; RtnNL (return Newline) cheats.  It needs to return two characters.
  239. ; Since GetEscChar only returns a single character, this code goes ahead
  240. ; and calls putc to output the CR and the returns the LF.
  241. ;
  242. RtnNL:        mov    al, cr
  243.         call    PutIt
  244.         mov    al, lf
  245.         ret
  246. ;
  247. RtnTab:        mov    al, tab
  248.         ret
  249. ;
  250. RtnBS:        mov    al, bs
  251.         ret
  252. ;
  253. RtnRtn:        mov    al, cr
  254.         ret
  255. ;
  256. RtnLF:        mov    al, lf
  257.         ret
  258. ;
  259. RtnFF:        mov    al, ff
  260. RtnChar:    ret
  261. ;
  262. GetEscChar    endp
  263. ;
  264. ;
  265. ;
  266. GetFmtItem    proc    near
  267.         lodsb                ;Get char beyond "%"
  268. ;
  269.         mov    cx, 1            ;Default field width is 1.
  270.         mov    dl, 0            ;Default is right justified
  271.         mov    dh, ' '            ;Default fill char is space.
  272.         mov    ah, ' '            ;Assume straight ptr, not handle.
  273. ;
  274. ; See if the user wants the value left justified:
  275. ;
  276.         cmp    al, '-'
  277.         jne    NotLeftJust
  278.         inc    dl            ;Set to right justified
  279.         lodsb                ;Get next character.
  280. ;
  281. ; See if the user wants to change the padding character.
  282. ;
  283. NotLeftJust:    cmp    al, '\'
  284.         jne    NoPadChange
  285.         lodsb                ;Get Padding Character.
  286.         mov    dh, al            ;Save padding character.
  287.         lodsb                ;Get next character
  288. ;
  289. ; See if the user wants a different field width:
  290. ;
  291. NoPadChange:    cmp    al, '0'
  292.         jb    NoFldWidth
  293.         cmp    al, '9'
  294.         ja    NoFldWidth
  295.         call    GetDecVal
  296. ;
  297. ; See if the user wants to specify a handle rather than a straight pointer
  298. ;
  299. NoFldWidth:    cmp    al, '^'
  300.         jne     ChkFmtChars
  301.         mov    ah, al
  302.         lodsb                ;Skip "^" character
  303. ;
  304. ; Okay, process the format characters down here.
  305. ;
  306. ChkFmtChars:    and    al, 05fh        ;l.c. -> U.C.
  307.         cmp    al, 'D'
  308.         je    PrintDec
  309.         cmp    al, 'I'
  310.         je    PrintDec
  311.         cmp    al, 'C'
  312.         je    PrintChar
  313. ;
  314.         cmp    al, 'X'
  315.         jne    TryH
  316.         jmp    PrintHexWord
  317. ;
  318. TryH:        cmp    al, 'H'
  319.         jne    TryU
  320.         jmp    PrintHexByte
  321. ;
  322. TryU:        cmp    al, 'U'
  323.         jne    TryString
  324.         jmp    PrintUDec
  325. ;
  326. TryString:    cmp    al, 'S'
  327.         jne    TryLong
  328.         jmp    PrintString
  329. ;
  330. TryLong:    cmp    al, 'L'
  331.         jne    Default
  332. ;
  333. ; If we've got the "L" modifier, this is a long value to print, get the
  334. ; data type character as the next value:
  335. ;
  336.         lodsb
  337.         and    al, 05fh        ;l.c. -> U.C.
  338.         cmp    al, 'D'
  339.         je    JmpDec
  340.         cmp    al, 'I'
  341.         jne    TryLU
  342. JmpDec:        jmp    LongDec
  343. ;
  344. TryLU:        cmp    al, 'U'
  345.         jne    TryX
  346.         jmp    LongU
  347. ;
  348. TryX:        cmp    al, 'X'
  349.         jne    Default
  350.         jmp    LongX
  351. ;
  352. ;
  353. ;
  354. ; If none of the above, simply return without printing anything.
  355. ;
  356. Default:        ret
  357. ;
  358. ;
  359. ;
  360. ;
  361. ;
  362. ; Print a signed decimal value here.
  363. ;
  364. PrintDec:    call    GetPtr            ;Get next pointer into ES:BX
  365.         mov    ax, es:[bx]        ;Get value to print.
  366.         call    sl_ISize        ;Get the size of this guy.
  367.         sub    cx, ax                 ;Compute padding
  368.         mov    ax, es:[bx]        ;Retrieve value to print.
  369.         js    NoPadDec        ;Is CX negative?
  370.         cmp    dl, 0            ;Right justified?
  371.         jne    LeftJustDec
  372.         call    PrintPad        ;Print padding characters
  373.         call    PutIti            ;Print the integer
  374.         ret                ;We're done!
  375. ;
  376. ; Print left justified value here.
  377. ;
  378. LeftJustDec:    call    PutIti
  379.         call    PrintPad
  380.         ret
  381. ;
  382. ; Print non-justified value here:
  383. ;
  384. NoPadDec:    call    PutIti
  385.         ret
  386. ;
  387. ;
  388. ;
  389. ; Print a character variable here.
  390. ;
  391. PrintChar:    call    GetPtr            ;Get next pointer into ES:BX
  392.         mov    al, es:[bx]        ;Retrieve value to print.
  393.                 dec    cx
  394.         js    NoPadChar        ;Is CX negative?
  395.         cmp    dl, 0            ;Right justified?
  396.         jne    LeftJustChar
  397.         call    PrintPad        ;Print padding characters
  398.         call    PutIt            ;Print the character
  399.         ret                ;We're done!
  400. ;
  401. ; Print left justified value here.
  402. ;
  403. LeftJustChar: